package solutions.ferpa.ztest.intf;

import br.com.telescope.adsrt.dom.DomDate;
import br.com.telescope.adsrt.dom.DomDouble;
import br.com.telescope.adsrt.dom.DomFlag;
import br.com.telescope.adsrt.dom.DomId;
import br.com.telescope.adsrt.dom.DomText;
import br.com.telescope.adsrt.dom.DomTextLong;
import br.com.telescope.adsrt.dom.DomUpper;
import br.com.telescope.adsrt.lib.*;
import br.com.telescope.adsrt.lib.AdsException;
import br.com.telescope.adsrt.lib.Form;
import br.com.telescope.sql.ModelQuery;
import br.com.telescope.t2.EntityBinding;
import br.com.telescope.t2.ModuleNavigator;
import br.com.telescope.t2.ServiceModel;
import br.com.telescope.t2.exception.ApplicationRuntimeException;
import br.com.telescope.t2.feature.AbstractFeature;
import br.com.telescope.t2.feature.DeleteFeature;
import br.com.telescope.t2.feature.InsertFeature;
import br.com.telescope.t2.feature.ListFeature;
import br.com.telescope.t2.feature.LookupFeature;
import br.com.telescope.t2.feature.QueryFeature;
import br.com.telescope.t2.feature.UpdateFeature;
import br.com.telescope.t2.feature.ViewFeature;
import br.com.telescope.util.ObjectUtil;
import solutions.ferpa.ztest.ent.*;
import solutions.ferpa.ztest.intf.*;

/**
 * Instrumentos para ensaios.
 * <p>
 * Interface para manutenção de Instrumento para ensaio
 * <P>
 * Telescope origin: ZTEST.CAD_INSTRUMENTO_ENSAIO
 * <P>
 * Base entity: ZTEST.INSTRUMENTO_ENSAIO
 * <P>
 * @author TELESCOPE - Build task T2 Web Interface Generator
 * <P>
 * @version 0.1
 */
public class CadInstrumentoEnsaio extends ServiceModel {
    
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    public static final String GLOBAL_NAME = "ZTEST.CAD_INSTRUMENTO_ENSAIO";
    
    @Override
    public String globalName() {
        return GLOBAL_NAME;
    }
    
    {
        setTitle("Instrumentos para ensaios");
    }
    
    protected EntInstrumentoEnsaio base;
    protected EntCertificadoCalibracao crtf;
    protected EntTipoInstrumentoEnsaio tint;
    protected EntInstrumentoEnsaio rec; // NEED_TJW1_COMPATIBILITY
    
    // Record items
    private DomUpper aNome;
    private DomText aCodigo;
    private DomTextLong aDescricao;
    private DomFlag aAtivo;
    private DomDouble aIntervaloValorInicial;
    private DomDouble aIntervaloValorFinal;
    private DomUpper aUnidadeMedida;
    private DomText aCertificado;
    private DomDate aDataValidadeCertificado;
    private DomId aId;
    private DomId aTipoInstrumentoEnsaioId;
    private DomDouble aDesvioPadraoAceitavel;
    private DomText aCrtfCertificado;
    private DomDate aCrtfDataValidade;
    private DomDate aCrtfDataCalibracao;
    private DomUpper aTintNome;
    private DomFlag aTintEComponente;
    
    // Query items
    private DomFlag qTintEComponente;
    private DomUpper qTintNome;
    private DomFlag qAtivo;
    private DomText qCodigo;
    private DomText qCertificado;
    private DomDate qDataValidadeCertificado;
    private DomUpper qNome;
    
    @Override
    public String getBaseSql() {
        return "select BASE.*"
                + " , CRTF.CERTIFICADO as CRTF_CERTIFICADO"
                + " , CRTF.DATA_VALIDADE as CRTF_DATA_VALIDADE"
                + " , CRTF.DATA_CALIBRACAO as CRTF_DATA_CALIBRACAO"
                + " , TINT.NOME as TINT_NOME"
                + " , TINT.E_COMPONENTE as TINT_E_COMPONENTE"
                + " , CRTF.ID as Z_CRTF_ID"
                + " , TINT.ID as Z_TINT_ID"
                + " from INSTRUMENTO_ENSAIO BASE"
                + " left join CERTIFICADO_CALIBRACAO CRTF on CRTF.ID = BASE.CERTIFICADO_CALIBRACAO_CORRENTE_ID"
                + " join TIPO_INSTRUMENTO_ENSAIO TINT on TINT.ID = BASE.TIPO_INSTRUMENTO_ENSAIO_ID";
    }
    
    @Override
    public void initAttributes() {
        
        aNome = new DomUpper();
        aNome.context(ctx).name("NOME").label("Sigla do instrumento (tag)");
        
        aCodigo = new DomText();
        aCodigo.context(ctx).name("CODIGO").label("Código");
        
        aDescricao = new DomTextLong();
        aDescricao.context(ctx).name("DESCRICAO").label("Descrição do instrumento");
        
        aAtivo = new DomFlag();
        aAtivo.context(ctx).name("ATIVO").label("Instrumento ativo");
        aAtivo.setDefaultValue("S");
        
        aIntervaloValorInicial = new DomDouble();
        aIntervaloValorInicial.context(ctx).name("INTERVALO_VALOR_INICIAL").label("Intervalo (Valor inicial)");
        
        aIntervaloValorFinal = new DomDouble();
        aIntervaloValorFinal.context(ctx).name("INTERVALO_VALOR_FINAL").label("Intervalo (Valor final)");
        
        aUnidadeMedida = new DomUpper();
        aUnidadeMedida.context(ctx).name("UNIDADE_MEDIDA").label("Unidade de medida do valor");
        
        aCertificado = new DomText();
        aCertificado.context(ctx).name("CERTIFICADO").label("Certificado do instrumento");
        
        aDataValidadeCertificado = new DomDate();
        aDataValidadeCertificado.context(ctx).name("DATA_VALIDADE_CERTIFICADO").label("Validade do certificado do instrumento");
        
        aId = new DomId();
        aId.context(ctx).name("ID").label("Id");
        
        aTipoInstrumentoEnsaioId = new DomId();
        aTipoInstrumentoEnsaioId.context(ctx).name("TIPO_INSTRUMENTO_ENSAIO_ID").label("Tipo do instrumento de ensaio");
        
        aDesvioPadraoAceitavel = new DomDouble();
        aDesvioPadraoAceitavel.context(ctx).name("DESVIO_PADRAO_ACEITAVEL").label("Incerteza (desvio permitido)");
        
        aCrtfCertificado = new DomText();
        aCrtfCertificado.context(ctx).name("CRTF_CERTIFICADO").label("Certificado da calibração");
        aCrtfCertificado.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT CERTIFICADO as valor"
                + " , CERTIFICADO as pesquisar"
                + " , CERTIFICADO as descricao"
                + " from CERTIFICADO_CALIBRACAO CRTF)", "q"));
        aCrtfCertificado.setAutocompleteLength(2);
        
        aCrtfDataValidade = new DomDate();
        aCrtfDataValidade.context(ctx).name("CRTF_DATA_VALIDADE").label("Data de validade da calibração");
        aCrtfDataValidade.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT DATA_VALIDADE as valor"
                + " , DATA_VALIDADE as pesquisar"
                + " , DATA_VALIDADE as descricao"
                + " from CERTIFICADO_CALIBRACAO CRTF)", "q"));
        aCrtfDataValidade.setAutocompleteLength(2);
        
        aCrtfDataCalibracao = new DomDate();
        aCrtfDataCalibracao.context(ctx).name("CRTF_DATA_CALIBRACAO").label("Data da calibração");
        aCrtfDataCalibracao.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT DATA_CALIBRACAO as valor"
                + " , DATA_CALIBRACAO as pesquisar"
                + " , DATA_CALIBRACAO as descricao"
                + " from CERTIFICADO_CALIBRACAO CRTF)", "q"));
        aCrtfDataCalibracao.setAutocompleteLength(2);
        
        aTintNome = new DomUpper();
        aTintNome.context(ctx).name("TINT_NOME").label("Tipo do instrumento");
        aTintNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from TIPO_INSTRUMENTO_ENSAIO TINT)", "q"));
        aTintNome.setAutocompleteLength(0);
        
        aTintEComponente = new DomFlag();
        aTintEComponente.context(ctx).name("TINT_E_COMPONENTE").label("É um componente/dispositivo?");
        aTintEComponente.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT E_COMPONENTE as valor"
                + " , E_COMPONENTE as pesquisar"
                + " , E_COMPONENTE as descricao"
                + " from TIPO_INSTRUMENTO_ENSAIO TINT)", "q"));
        aTintEComponente.setAutocompleteLength(0);
        
        
        qTintEComponente = new DomFlag();
        qTintEComponente.context(ctx).name("TINT_E_COMPONENTE").label("É um componente/dispositivo?");
        qTintEComponente.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT E_COMPONENTE as valor"
                + " , E_COMPONENTE as pesquisar"
                + " , E_COMPONENTE as descricao"
                + " from TIPO_INSTRUMENTO_ENSAIO TINT)", "q"));
        qTintEComponente.setAutocompleteLength(0);
        
        qTintNome = new DomUpper();
        qTintNome.context(ctx).name("TINT_NOME").label("Tipo do instrumento");
        qTintNome.setListOfValuesQuery(createQuery()
                .select("*")
                .from("(SELECT NOME as valor"
                + " , NOME as pesquisar"
                + " , NOME as descricao"
                + " from TIPO_INSTRUMENTO_ENSAIO TINT)", "q"));
        qTintNome.setAutocompleteLength(0);
        
        qAtivo = new DomFlag();
        qAtivo.context(ctx).name("ATIVO").label("Instrumento ativo");
        
        qCodigo = new DomText();
        qCodigo.context(ctx).name("CODIGO").label("Código");
        
        qCertificado = new DomText();
        qCertificado.context(ctx).name("CERTIFICADO").label("Certificado do instrumento");
        
        qDataValidadeCertificado = new DomDate();
        qDataValidadeCertificado.context(ctx).name("DATA_VALIDADE_CERTIFICADO").label("Validade do certificado do instrumento");
        
        qNome = new DomUpper();
        qNome.context(ctx).name("NOME").label("Sigla do instrumento (tag)");
    }
    
    @Override
    public void initEntityBindings() {
        EntityBinding binding;
        
        binding = new EntityBinding("ZTEST.TIPO_INSTRUMENTO_ENSAIO", "TINT", "Z_TINT_ID", "ZTEST.CAD_TIPO_DISPOSITIVO_ENSAIO.VIEW");
        binding.addFields(aTintNome, aTintEComponente);
        entityBindings.add(binding);
    }
    
    @Override
    public String getQueryPkColumn() {
        return "BASE.ID";
    }
    
    @Override
    public void setId(String value) {
        this.aId.setValue(value);
    }
    
    @Override
    public EntInstrumentoEnsaio getRecord() {
        if (base == null) {
            base = new EntInstrumentoEnsaio(ctx);
            rec = base;
        }
        return this.base;
    }
    
    @Override
    public String getContextName() {
        return aNome.toText();
    }
    
    @Override
    public String getDefaultOrderBy() {
        return "NOME, CODIGO, TINT_NOME, TINT_E_COMPONENTE";
    }
    
    @Override
    public void translateInsertFks(Form form) {
        ModelQuery query;
        
        // TIPO_INSTRUMENTO_ENSAIO_ID
        try {
            if (form.hasFields("TINT_NOME")) {
                query = createQuery()
                        .select("TINT.ID")
                        .from("TIPO_INSTRUMENTO_ENSAIO", "TINT")
                        .filter("TINT.NOME", form.get("TINT_NOME"))
                        ;
                base.setTipoInstrumentoEnsaioId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
    }
    
    @Override
    public void translateUpdateFks(Form form) {
        ModelQuery query;
        
        // TIPO_INSTRUMENTO_ENSAIO_ID
        try {
            if (form.hasFields("TINT_NOME")) {
                query = createQuery()
                        .select("TINT.ID")
                        .from("TIPO_INSTRUMENTO_ENSAIO", "TINT")
                        .filter("TINT.NOME", form.get("TINT_NOME"))
                        ;
                base.setTipoInstrumentoEnsaioId(ObjectUtil.toLong(translateFk(query)));
            }
        } catch (AdsException ex) {
            throw new RuntimeException(ex);
        }
    }
    
    @Override
    public ModuleNavigator getDefaultModuleNavigator() {
        return new ModInstbase();
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="LIST">
    public class FList extends ListFeature {
        
        @Override
        public void initForm() {
            addField(aNome, "view");
            addField(aCodigo, "view");
            addField(aTintNome, "view");
            addField(aTintEComponente, "view");
            addField(aAtivo, "view");
            addField(aDataValidadeCertificado, "view");
        }
        
        {
            setFeatureName("LIST");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="VIEW">
    public class FView extends ViewFeature {
        
        @Override
        public void initForm() {
            addField(aNome, "view");
            addField(aCodigo, "view");
            addField(aDescricao, "view");
            addField(aTintNome, "view");
            addField(aTintEComponente, "view");
            addField(aAtivo, "view");
            addField(aIntervaloValorInicial, "view");
            addField(aIntervaloValorFinal, "view");
            addField(aUnidadeMedida, "view");
            addField(aCertificado, "view");
            addField(aDataValidadeCertificado, "view");
            addField(aCrtfCertificado, "view");
            addField(aCrtfDataValidade, "view");
            addField(aCrtfDataCalibracao, "view");
        }
        
        @Override
        public void posDisplay() {
            {
                CadInstrumentoUtilizado external = new CadInstrumentoUtilizado();
                external.setRuntime(ctx.clone());
                external.init();
                AbstractFeature feature = external.getFeature("LIST");
                external.setParameterIdInstrumentoBase(aId.getValue());
                external.setDetail(true);
                feature.setTitle("Outros instrumentos/componentes usados");
                feature.run();
            }
            {
                CadModeloEnsaioInstrumento external = new CadModeloEnsaioInstrumento();
                external.setRuntime(ctx.clone());
                external.init();
                AbstractFeature feature = external.getFeature("LIST");
                external.setParameterIdInstrumentoEnsaio(aId.getValue());
                external.setDetail(true);
                feature.setTitle("Modelos para ensaios neste instrumento");
                feature.run();
            }
        }
        
        {
            setFeatureName("VIEW");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="INSERT">
    public class FInsert extends InsertFeature {
        
        @Override
        public void initForm() {
            aNome.setOptional(false);
            addField(aNome, "rqd");
            aCodigo.setOptional(false);
            addField(aCodigo, "rqd");
            aDescricao.setOptional(false);
            addField(aDescricao, "rqd");
            aTintNome.setOptional(false);
            addField(aTintNome, "rqd");
            aTintEComponente.setEditable(false);
            addField(aTintEComponente, "view");
            addField(aIntervaloValorInicial, "opt");
            addField(aIntervaloValorFinal, "opt");
            addField(aUnidadeMedida, "opt");
            addField(aCertificado, "opt");
            addField(aDataValidadeCertificado, "opt");
            registerEvent("ON_CHANGE", "TINT_NOME", "desabilitarCamposInterface");
        }
        
        {
            setFeatureName("INSERT");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="UPDATE">
    public class FUpdate extends UpdateFeature {
        
        @Override
        public void initForm() {
            aNome.setOptional(false);
            addField(aNome, "rqd");
            aCodigo.setOptional(false);
            addField(aCodigo, "rqd");
            aDescricao.setOptional(false);
            addField(aDescricao, "rqd");
            aTintNome.setOptional(false);
            addField(aTintNome, "rqd");
            aTintEComponente.setEditable(false);
            addField(aTintEComponente, "view");
            aAtivo.setOptional(false);
            addField(aAtivo, "rqd");
            addField(aIntervaloValorInicial, "opt");
            addField(aIntervaloValorFinal, "opt");
            addField(aUnidadeMedida, "opt");
            addField(aCertificado, "opt");
            addField(aDataValidadeCertificado, "opt");
            aCrtfCertificado.setEditable(false);
            addField(aCrtfCertificado, "view");
            aCrtfDataValidade.setEditable(false);
            addField(aCrtfDataValidade, "view");
            aCrtfDataCalibracao.setEditable(false);
            addField(aCrtfDataCalibracao, "view");
        }
        
        @Override
        public void preDisplay() {
            try {
                desabilitarCamposInterface();
            } catch (AdsException ex) {
                throw new ApplicationRuntimeException(ex);
            }
        }
        
        {
            setFeatureName("UPDATE");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="DELETE">
    public class FDelete extends DeleteFeature {
        
        @Override
        public void initForm() {
            addField(aNome, "view");
            addField(aCodigo, "view");
            addField(aDescricao, "view");
            addField(aTintNome, "view");
            addField(aAtivo, "view");
        }
        
        {
            setFeatureName("DELETE");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="QUERY">
    public class FQuery extends QueryFeature {
        
        @Override
        public void initForm() {
            addField(qNome, "opt");
            addField(qCodigo, "opt");
            addField(qTintNome, "opt");
            addField(qTintEComponente, "opt");
            addField(qAtivo, "opt");
            addField(qCertificado, "opt");
            addField(qDataValidadeCertificado, "opt");
        }
        
        {
            setFeatureName("QUERY");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="TINT_NOME_LOOKUP">
    public class FTintNomeLookup extends LookupFeature {
        
        @Override
        public void initForm() {
            aTintNome.setEditable(true);
            addField(aTintNome, "opt");
            aTintEComponente.setEditable(false);
            addField(aTintEComponente, "view");
        }
        
        @Override
        public ModelQuery getLookupQuery() {
            return createQuery()
                    .select("TINT.NOME as TINT_NOME")
                    .select("TINT.E_COMPONENTE as TINT_E_COMPONENTE")
                    .from("TIPO_INSTRUMENTO_ENSAIO", "TINT")
                    ;
        }
        
        {
            setFeatureName("TINT_NOME_LOOKUP");
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="initFeatures">
    
    @Override
    protected void initFeatures() {
        addFeature(new FList());
        addFeature(new FView());
        addFeature(new FInsert());
        addFeature(new FUpdate());
        addFeature(new FDelete());
        addFeature(new FQuery());
        addFeature(new FTintNomeLookup());
        super.initFeatures();
    }
    
    @Override
    public String getDefaultFeature() {
        return "LIST";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Getters and Setters">
    
    public String getNome() {
        return aNome.getValue();
    }
    
    public void setNome(String value) {
        this.aNome.setValue(value);
    }
    
    public String getCodigo() {
        return aCodigo.getValue();
    }
    
    public void setCodigo(String value) {
        this.aCodigo.setValue(value);
    }
    
    public String getDescricao() {
        return aDescricao.getValue();
    }
    
    public void setDescricao(String value) {
        this.aDescricao.setValue(value);
    }
    
    public String getAtivo() {
        return aAtivo.getValue();
    }
    
    public void setAtivo(String value) {
        this.aAtivo.setValue(value);
    }
    
    public Double getIntervaloValorInicial() {
        return aIntervaloValorInicial.getValue();
    }
    
    public void setIntervaloValorInicial(Double value) {
        this.aIntervaloValorInicial.setValue(value);
    }
    
    public Double getIntervaloValorFinal() {
        return aIntervaloValorFinal.getValue();
    }
    
    public void setIntervaloValorFinal(Double value) {
        this.aIntervaloValorFinal.setValue(value);
    }
    
    public String getUnidadeMedida() {
        return aUnidadeMedida.getValue();
    }
    
    public void setUnidadeMedida(String value) {
        this.aUnidadeMedida.setValue(value);
    }
    
    public String getCertificado() {
        return aCertificado.getValue();
    }
    
    public void setCertificado(String value) {
        this.aCertificado.setValue(value);
    }
    
    public java.sql.Date getDataValidadeCertificado() {
        return aDataValidadeCertificado.getValue();
    }
    
    public void setDataValidadeCertificado(java.sql.Date value) {
        this.aDataValidadeCertificado.setValue(value);
    }
    
    @Override
    public Long getId() {
        return aId.getValue();
    }
    
    public void setId(Long value) {
        this.aId.setValue(value);
    }
    
    public Long getTipoInstrumentoEnsaioId() {
        return aTipoInstrumentoEnsaioId.getValue();
    }
    
    public void setTipoInstrumentoEnsaioId(Long value) {
        this.aTipoInstrumentoEnsaioId.setValue(value);
    }
    
    public Double getDesvioPadraoAceitavel() {
        return aDesvioPadraoAceitavel.getValue();
    }
    
    public void setDesvioPadraoAceitavel(Double value) {
        this.aDesvioPadraoAceitavel.setValue(value);
    }
    
    public String getCrtfCertificado() {
        return aCrtfCertificado.getValue();
    }
    
    public void setCrtfCertificado(String value) {
        this.aCrtfCertificado.setValue(value);
    }
    
    public java.sql.Date getCrtfDataValidade() {
        return aCrtfDataValidade.getValue();
    }
    
    public void setCrtfDataValidade(java.sql.Date value) {
        this.aCrtfDataValidade.setValue(value);
    }
    
    public java.sql.Date getCrtfDataCalibracao() {
        return aCrtfDataCalibracao.getValue();
    }
    
    public void setCrtfDataCalibracao(java.sql.Date value) {
        this.aCrtfDataCalibracao.setValue(value);
    }
    
    public String getTintNome() {
        return aTintNome.getValue();
    }
    
    public void setTintNome(String value) {
        this.aTintNome.setValue(value);
    }
    
    public String getTintEComponente() {
        return aTintEComponente.getValue();
    }
    
    public void setTintEComponente(String value) {
        this.aTintEComponente.setValue(value);
    }
    public String getQueryNome() {
        return qNome.getQueryValue();
    }
    
    public void setQueryNome(String value) {
        this.qNome.setQueryValue(value);
    }
    public String getQueryCodigo() {
        return qCodigo.getQueryValue();
    }
    
    public void setQueryCodigo(String value) {
        this.qCodigo.setQueryValue(value);
    }
    public String getQueryTintNome() {
        return qTintNome.getQueryValue();
    }
    
    public void setQueryTintNome(String value) {
        this.qTintNome.setQueryValue(value);
    }
    public String getQueryTintEComponente() {
        return qTintEComponente.getQueryValue();
    }
    
    public void setQueryTintEComponente(String value) {
        this.qTintEComponente.setQueryValue(value);
    }
    public String getQueryAtivo() {
        return qAtivo.getQueryValue();
    }
    
    public void setQueryAtivo(String value) {
        this.qAtivo.setQueryValue(value);
    }
    public String getQueryCertificado() {
        return qCertificado.getQueryValue();
    }
    
    public void setQueryCertificado(String value) {
        this.qCertificado.setQueryValue(value);
    }
    public String getQueryDataValidadeCertificado() {
        return qDataValidadeCertificado.getQueryValue();
    }
    
    public void setQueryDataValidadeCertificado(String value) {
        this.qDataValidadeCertificado.setQueryValue(value);
    }
    // </editor-fold>
    
    /**
     * Desabilitar campos da interface.
     */
    public void desabilitarCamposInterface() throws AdsException {
        // <user-code id="20626276" parentId="20626182" hashcode="-37add99a" length="1802">
        ctx.readFields(aTintNome);
        
        if (aTintNome.isNotNull()) {
            EntTipoInstrumentoEnsaio tipo = new EntTipoInstrumentoEnsaio(ctx);
            tipo.findByNome(aTintNome.getValue());
            if (tipo.valueOfEComponente().equals("S")) {
                if (tipo.valueOfOfereceDadosLeitura().equals("S")) {
                    aIntervaloValorInicial.setEditable(true);
                    aIntervaloValorInicial.setRequired(true);
                    aIntervaloValorFinal.setEditable(true);
                    aIntervaloValorFinal.setRequired(true);
                    aDesvioPadraoAceitavel.setEditable(true);
                    aUnidadeMedida.setEditable(true);
                } else {
                    aIntervaloValorInicial.setEditable(false);
                    aIntervaloValorInicial.setRequired(false);
                    aIntervaloValorFinal.setEditable(false);
                    aIntervaloValorFinal.setRequired(false);
                    aDesvioPadraoAceitavel.setEditable(false);
                    aUnidadeMedida.setEditable(false);
                }
                if (tipo.valueOfExigeCertificadoCalibracao().equals("S")) {
                    aCertificado.setEditable(true);
                    aCertificado.setRequired(true);
                    aDataValidadeCertificado.setEditable(true);
                    aDataValidadeCertificado.setRequired(true);
                } else {
                    aCertificado.setEditable(false);
                    aDataValidadeCertificado.setEditable(false);
                }
            } else {
                aIntervaloValorInicial.setEditable(false);
                aIntervaloValorInicial.setRequired(false);
                aIntervaloValorFinal.setEditable(false);
                aIntervaloValorFinal.setRequired(false);
                aDesvioPadraoAceitavel.setEditable(false);
                aUnidadeMedida.setEditable(false);
                aCertificado.setEditable(false);
                aDataValidadeCertificado.setEditable(false);
            }
            tipo.close();
        }
        // </user-code>
    }
    
    @Override
    public String getJsServiceFile() {
        return "ui/ztest/cad_instrumento_ensaio.js";
    }
}
